import { asyncRouterHandle } from "@/router/asyncRouter"
import { emitter } from "@/utils/bus.js"
import { asyncMenu } from "@/api/menu"
import { defineStore } from "pinia"
import { ref, watchEffect } from "vue"
import pathInfo from "@/pathInfo.json"
import { 主layout } from "@/router"
import { useRoute, useRouter } from 'vue-router'

const notLayoutRouterArr = []
const keepAliveRoutersArr = []
const nameMap = {}

// 将嵌套的路由数组扁平化，并附加额外信息，以便于在应用的任何地方快速查找和使用路由信息。
// 建立父子关系：为每个路由项添加一个 parent 属性，指向其父级路由对象，方便回溯。
// 信息整理：将路由项上的一些顶层属性（如 btns, hidden）移动或复制到其 meta 对象中，统一管理元数据。
// 特殊路由处理：识别并处理被标记为 defaultMenu: true 的路由，将其放入一个全局数组 notLayoutRouterArr，这类路由通常用于生成默认菜单或作为独立页面。
// 构建路由映射表：将每个路由项以其 name 为键存储到一个全局对象 routeMap 中，实现路由的 O (1) 时间复杂度快速查找。
// 递归处理子路由
// O (1) 是 算法时间复杂度 的一种表示，核心意思是 “算法的执行时间不随输入数据量的变化而变化”，无论处理的数据规模多大，耗时都基本固定，也被称为 “常数时间复杂度”。
const formatRouter = (routes, routeMap, parent) => {
    // console.log(`formatRouter ing👇`)
    routes &&
        routes.forEach(item => {
            item.parent = parent
            item.meta.btns = item.btns
            item.meta.hidden = item.hidden
            if (item.meta.defaultMenu === true) {
                if (!parent) {
                    item = { ...item, path: `/${item.path}` }
                    notLayoutRouterArr.push(item)
                }
            }
            routeMap[item.name] = item
            if (item.children && item.children.length > 0) {
                formatRouter(item.children, routeMap, item)
            }
        })
}

const 找组件对应name = routes => {
    // console.log(`找组件对应name ing👇`)
    routes &&
        routes.forEach(item => {
            // console.log(`item 👉`,item)
            // 子菜单中有 keep-alive 的，父菜单也必须 keep-alive，否则无效。这里将子菜单中有 keep-alive 的父菜单也加入。
            // 不存在，在 permission路由守卫 处理的时候把父级删除了，根本没影响了👆
            // if ((item.children && item.children.some(ch => ch.meta.keepAlive) || item.meta.keepAlive)) {
            if (item.meta.keepAlive) {
                // console.log(`item 👉`, item)
                const path = item.meta.path
                keepAliveRoutersArr.push(pathInfo[path])
                nameMap[item.name] = pathInfo[path]
            }
            if (item.children && item.children.length > 0) {
                找组件对应name(item.children)
            }
        })
}

export const useRouterStore = defineStore("router", () => {
    const route = useRoute()
    const router = useRouter()

    const 相续路由组 = ref([])
    const 取动态路由计数 = ref(0)
    const 予相续路由组 = history => {
        // console.log(`予相续路由组 ing👇`)
        const keepArrTemp = []
        history.forEach(item => {
            // console.log(`history item 👉`,item)
            if (nameMap[item.name]) {
                keepArrTemp.push(nameMap[item.name])
            } else {
                // 组件name 和 路由name是一致的情况
                keepArrTemp.push(item.name)
            }
        })
        相续路由组.value = Array.from(new Set(keepArrTemp))
        // console.log(`设置 相续路由组.value 👉`, 相续路由组.value)
    }
    emitter.on("setKeepAlive", 予相续路由组)
    const asyncRouters = ref([])
    const topMenu = ref([])
    const leftMenu = ref([])
    const menuMap = {}
    const topActive = ref("")

    const setLeftMenu = name => {
        // console.log(`setLeftMenu name 👉`,name)
        // sessionStorage.setItem('topActive', name)
        topActive.value = name
        if (menuMap[name]?.children) {
            leftMenu.value = menuMap[name].children
        }
        return menuMap[name]?.children
    }

    watchEffect(() => {
        let topActive = sessionStorage.getItem("topActive")
        let firstHasChildren = ""
        asyncRouters.value[0]?.children.forEach(item => {
            if (item.hidden) return
            menuMap[item.name] = item
            if (!firstHasChildren && item.children && item.children.length > 0) {
                firstHasChildren = item.name
            }
            topMenu.value.push({ ...item, children: [] })
        })

        if (!menuMap[topActive]?.children && firstHasChildren) {
            topActive = firstHasChildren
        }
        setLeftMenu(topActive)
    })

    const routeMap = {}
    // 从后台获取动态路由
    const SetAsyncRouter = async () => {
        取动态路由计数.value++
        const baseRouter = [主layout]
        const asyncRouterRes = await asyncMenu()
        const asyncRouter = asyncRouterRes.data.menus
        // console.log(`asyncRouter 👉`, asyncRouter)
        asyncRouter &&
            asyncRouter.push({
                path: "reload",
                name: "Reload",
                hidden: true,
                meta: {
                    title: "",
                    closeTab: true,
                },
                component: "view/error/reload.vue",
            })
        formatRouter(asyncRouter, routeMap)
        // console.log(`asyncRouter 👉`, asyncRouter)

        // baseRouter[0].children = asyncRouter
        baseRouter[0].children.push(...asyncRouter)
        if (notLayoutRouterArr.length !== 0) {
            baseRouter.push(...notLayoutRouterArr)
        }
        asyncRouterHandle(baseRouter)
        找组件对应name(asyncRouter)
        asyncRouters.value = baseRouter
        return true
    }

    function 予跳转(req) {
        const query = {}
        const params = {}
        routeMap[req]?.parameters &&
            routeMap[req]?.parameters.forEach(item => {
                if (item.type === "query") {
                    query[item.key] = item.value
                } else {
                    params[item.key] = item.value
                }
            })
        if (req === route.name) return
        if (req.indexOf("http://") > -1 || req.indexOf("https://") > -1) {
            window.open(req)
        } else {
            router.push({ name: req, query, params })
        }
    }

    return {
        予跳转,
        topActive,
        setLeftMenu,
        topMenu,
        leftMenu,
        asyncRouters,
        相续路由组,
        取动态路由计数,
        SetAsyncRouter,
        routeMap,
    }
})
